home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / kernel / rpc / rpcServer.h < prev    next >
C/C++ Source or Header  |  1992-12-18  |  8KB  |  255 lines
  1. /*
  2.  * rpcServer.h --
  3.  *
  4.  *    Definitions for the server side of the RPC system.
  5.  *
  6.  * Copyright (C) 1985 Regents of the University of California
  7.  * All rights reserved.
  8.  *
  9.  *
  10.  * $Header: /cdrom/src/kernel/Cvsroot/kernel/rpc/rpcServer.h,v 9.13 91/05/08 20:01:34 mgbaker Exp $ SPRITE (Berkeley)
  11.  */
  12.  
  13. #ifndef _RPCSERVER
  14. #define _RPCSERVER
  15.  
  16. #ifdef KERNEL
  17. #include <net.h>
  18. #include <sync.h>
  19. #include <timer.h>
  20. #include <rpcTypes.h>
  21. #include <rpcPacket.h>
  22. #include <rpcSrvStat.h>
  23. #include <rpcHistogram.h>
  24. #else
  25. #include <kernel/net.h>
  26. #include <kernel/sync.h>
  27. #include <kernel/timer.h>
  28. #include <kernel/rpcTypes.h>
  29. #include <kernel/rpcPacket.h>
  30. #include <kernel/rpcSrvStat.h>
  31. #include <kernel/rpcHistogram.h>
  32. #endif /* KERNEL */
  33.  
  34.  
  35. /*
  36.  *      Definition of the state table maintained for all the RPC server
  37.  *      processes.  The state of each server is similar to the state kept
  38.  *      for each client in the channel table.  It includes the current RPC
  39.  *      sequence number, the client's address and channel number, and
  40.  *      buffer space for input and reply message headers.  The server
  41.  *      state table is scanned during dispatch in order to find the server
  42.  *      for incoming messages.
  43.  */
  44. typedef struct RpcServerState {
  45.     /*
  46.      * Rpc transaction state:  There are state bits to drive the algorithm,
  47.      * the values are described below with their definitions.
  48.      */
  49.     int            state;
  50.     /*
  51.      * The current RPC sequence number.
  52.      */
  53.     unsigned int    ID;
  54.     /*
  55.      * The index is a self reference to this server's state.
  56.      * It is kept here because it will be part of the packet header.
  57.      */
  58.     int            index;
  59.     /*
  60.      * Servers go into an aging state after waiting for a reply
  61.      * from the client for too long.  A callback procedure is put
  62.      * in the the timer queue to probe the client, and the server's
  63.      * age is recorded here.
  64.      */
  65.     int            age;
  66.     Timer_QueueElement timeoutItem;
  67.  
  68.     /*
  69.      * The client's host ID and channel number uniquely identify it.
  70.      * This is used to match incoming requests to the correct server process.
  71.      */
  72.     int            clientID;
  73.     int            channel;
  74.  
  75.     /*
  76.      * Synchronization between the dispatcher and the server processes
  77.      * is with 'mutex', a master lock.  The condition variable is
  78.      * used to notify the server process that it has input.
  79.      */
  80.     Sync_Semaphore    mutex;
  81.     Sync_Condition    waitCondition;
  82.  
  83.     /*
  84.      * This bitmask indicates which fragments our client has recieved.
  85.      * It is used by RpcOutput for partial resends.
  86.      */
  87.     unsigned    int    fragsDelivered;
  88.     /*
  89.      * This bitmask indicates which fragments we've gotten.
  90.      * It is maintained by ServerDispatch and returned to the
  91.      * client in partial acknowledgments.
  92.      */
  93.     int            fragsReceived;
  94.  
  95.     /*
  96.      * Header and buffer specifications for request messages.
  97.      */
  98.     RpcHdr        requestRpcHdr;
  99.     RpcBufferSet    request;
  100.  
  101.     /*
  102.      * Header and buffer specification for the reply message.
  103.      */
  104.     RpcHdr        replyRpcHdr;
  105.     RpcBufferSet    reply;
  106.  
  107.     /*
  108.      * A callback procedure is used to free up the reply.  This is called
  109.      * by the RPC module when it knows the client has successfully received
  110.      * the reply, or it has crashed.
  111.      */
  112.     int            (*freeReplyProc) _ARGS_((ClientData freeReplyData));
  113.     ClientData        freeReplyData;
  114.  
  115.     /*
  116.      * An array of RPC headers and buffer specifications is needed
  117.      * when fragmenting a large reply.
  118.      */
  119.     RpcHdr        fragRpcHdr[RPC_MAX_NUM_FRAGS];
  120.     RpcBufferSet    fragment[RPC_MAX_NUM_FRAGS];
  121.  
  122.     /*
  123.      * Buffer space for server acknowlegment messages.
  124.      */
  125.     RpcHdr        ackRpcHdr;
  126.     RpcBufferSet    ack;
  127.  
  128.     /*
  129.      * Two temporaries are needed to record the
  130.      * amount of data actually sent by the client.
  131.      */
  132.     int            actualDataSize;
  133.     int            actualParamSize;
  134.  
  135. } RpcServerState;
  136.  
  137. /*
  138.  * These are data structures for sending negative acknowledgements when
  139.  * there's no server available to allocate to a client channel.  Since there's
  140.  * no server available, this stuff isn't part of the server state.
  141.  */
  142. typedef struct  NackData {
  143.     RpcHdr              *rpcHdrArray;        /* headers to transmit */
  144.     int            *hdrState;        /* which headers are free */
  145.     RpcBufferSet        *bufferSet;        /* buffers for transmission */
  146.     Sync_Semaphore      mutex;            /* protect nack data */
  147.     int            numFree;        /* are any free? */
  148. } NackData;
  149. extern    NackData    rpcNack;
  150. extern    int        rpc_NumNackBuffers;    /* settable number of buffers */
  151. #define    RPC_NACK_FREE        0        /* Can use this header */
  152. #define    RPC_NACK_WAITING    1        /* Hdr full, waiting for xmit */
  153. #define    RPC_NACK_XMITTING    2        /* Hdr being xmitted */
  154.  
  155.  
  156. /*
  157.  * Definitions of state bits for a remote procedure call.
  158.  *  SRV_NOTREADY    The server has no buffer space yet.
  159.  *  SRV_FREE        The server is free.
  160.  *  SRV_BUSY        The server is working on a request.
  161.  *  SRV_WAITING        The server has sent off its reply.
  162.  *  SRV_AGING        The server is aging, waiting for a client request.
  163.  *  SRV_FRAGMENT     ... waiting for reasembly of a fragmented request.
  164.  *  SRV_NO_REPLY    The server is explicitly not returning a reply
  165.  *            in response to a broadcast request.  This state
  166.  *            prevents the dispatcher from sending acknowledments
  167.  *            and prevents the top level server process from
  168.  *            sending a default error reply to the client.
  169.  * SRV_STUCK        This server is apparently stuck during an RPC for
  170.  *            a dead or rebooted client.  The server will not
  171.  *            be picked by the dispatcher until its current
  172.  *            RPC completes and this flag is reset.
  173.  */
  174. #define SRV_NOTREADY    0x00
  175. #define SRV_FREE    0x01
  176. #define SRV_BUSY    0x02
  177. #define SRV_WAITING    0x04
  178. #define SRV_AGING    0x08
  179. #define SRV_FRAGMENT    0x10
  180. #define SRV_NO_REPLY    0x20
  181. #define SRV_STUCK    0x40
  182.  
  183. /*
  184.  * The server's state table has a maximum number of entries, but not all
  185.  * the entries are initialized and have an associated process.  The current
  186.  * number of existing server processes is recorded in rpcNumServers.  Up to
  187.  * rpcMaxServer processes may be created by Rpc_Deamon.  rpcMaxServers may
  188.  * not be set above rpcAbsoluteMaxServers.  (This is for allowing the
  189.  * maximum number of servers to be changed by a system call and thus set
  190.  * in boot scripts differently for different servers.)
  191.  */
  192. extern RpcServerState **rpcServerPtrPtr;
  193. extern int        rpcMaxServers;
  194. extern int        rpcNumServers;
  195. extern int        rpcAbsoluteMaxServers;
  196.  
  197. /*
  198.  * Whether or not the server should send negative acknowledgements.
  199.  */
  200. extern    Boolean        rpcSendNegAcks;
  201.  
  202. /*
  203.  * The service procedure switch. This is indexed by procedure number.
  204.  */
  205. typedef ReturnStatus (*IntProc) _ARGS_((ClientData srvToken, int clientID, 
  206.             int command, Rpc_Storage *storagePtr));
  207. typedef struct RpcService {
  208.     IntProc    serviceProc;
  209.     char    *name;
  210. } RpcService;
  211. extern RpcService rpcService[];
  212.  
  213. /*
  214.  * A histogram of the service times for the different RPCs.
  215.  */
  216. extern Rpc_Histogram    *rpcServiceTime[];
  217.  
  218. /*
  219.  * A raw count of the number of service calls.
  220.  */
  221. extern int        rpcServiceCount[];
  222.  
  223. /*
  224.  * For determining whether rpc being handled by this server was sent
  225.  * to the broadcast server ID.
  226.  */
  227. #define    RPC_IS_BROADCAST(srvrPtr)    \
  228.     (((RpcServerState *) srvrPtr)->requestRpcHdr.serverID == RPC_BROADCAST_SERVER_ID)
  229.  
  230. /*
  231.  * For tracing calls.
  232.  */
  233. extern void Rpc_OkayToTrace _ARGS_((Boolean okay));
  234. extern void Rpc_FreeTraces _ARGS_((void));
  235. extern void RpcAddServerTrace _ARGS_((RpcServerState *srvPtr, RpcHdr *rpcHdrPtr, Boolean noneThere, int num));
  236. extern ReturnStatus Rpc_DumpServerTraces _ARGS_((int length, RpcServerUserStateInfo *resultPtr, int *lengthNeededPtr));
  237.  
  238. /*
  239.  * Forward declarations.
  240.  */
  241. extern RpcServerState *RpcServerAlloc _ARGS_((RpcHdr *rpcHdrPtr));
  242. extern RpcServerState *RpcServerInstall _ARGS_((void));
  243. extern void RpcServerDispatch _ARGS_((register RpcServerState *srvPtr, register RpcHdr *rpcHdrPtr));
  244. extern RpcServerState *RpcInitServerState _ARGS_((int index));
  245. extern void RpcAck _ARGS_((RpcServerState *srvPtr, int flags));
  246. extern void RpcResend _ARGS_((RpcServerState *srvPtr));
  247. extern void RpcProbe _ARGS_((RpcServerState *srvPtr));
  248. extern void RpcSrvInitHdr _ARGS_((RpcServerState *srvPtr, RpcHdr *rpcHdrPtr, RpcHdr *requestHdrPtr));
  249. extern void RpcSetNackBufs _ARGS_((void));
  250. extern void RpcReclaimServers _ARGS_((Boolean serversMaxed));
  251. extern void RpcInitServerTraces _ARGS_((void));
  252.  
  253.  
  254. #endif /* _RPCSERVER */
  255.